System and method of epsilon removal of weighted automata and transducers

ABSTRACT

An improved -removal method is disclosed that computes for any input weighted automaton A with -transitions an equivalent weighted automaton B with no -transitions. The method comprises two main steps. The first step comprises computing for each state p of the automaton A its -closure. The second step in the method comprises modifying the outgoing transitions of each state p by removing those labeled with . The method next comprises adding to the set of transitions leaving the state p non--transitions leaving each state q in the set of states reachable from p via a path labeled with with their weights pre--multiplied by the -distance from state p to state q in the automaton A. State p is a final state if some state q within the set of states reachable from p via a path labeled with is final and the final weight ρ ⁢ [ p ] = ⊕ q ⁢ ⁢ ε ⁢ ⁢ e ⁡ [ p ] ⋒ F ⁢ ( d ⁡ [ p , q ] ⁢ ⁢ ρ ⁡ [ q ] ) .

RELATED APPLICATION

The present application is related to Ser. No. 11/214,254 entitled “A System and Method of Epsilon Removal of Weighted Automata and Transducers”, by Mehryar Mohri, assigned to the assignee of the present invention. The contents of that application are incorporated herein.

1. FIELD OF THE INVENTION

The present invention is directed to a system and method for epsilon removal of weighted automata and transducers. More specifically, the present invention relates to a system and method of computing a weighted automaton B with no epsilons that is equivalent to the input automaton A.

2. BRIEF DESCRIPTION OF THE RELATED ART

In natural language processing and speech recognition systems, certain algorithms and processes have been developed to receive speech signals and determine what word or phrase has been spoken. The algorithms and processes for speech processing applications are a particular application of finite state machines (FSMs). Finite state machines are devices that allow for simple and accurate design of sequential logic and control functions. Finite state machines have many applications and while the present disclosure specifically relates to speech recognition systems, the basic principles disclosed herein may have other applications beyond speech recognition or signal processing. Some examples of other contexts in which the present invention may apply include text-processing systems such as information extraction systems, or systems for information retrieval, pattern matching, and computational biology. An FSM is called a “finite” state machine because there are only a limited (finite) number of states. In a simple sense, a door is a finite state machine because it can be in one of two states: open or closed.

A main design tool for FSMs is the state transition diagram or state diagram. The state transition diagram illustrates the relationships between the system states and the events that cause the system to change from one state to the next. FIG. 1, discussed below, illustrates an example state transition diagram in the speech recognition process. Disclosed herein are previous methods and systems for converting a particular FSM into a more simple and efficient FSM that maintains the same functionality as the original FSM. The previous methods relate to removing unnecessary transitions from state to state within an FSM.

It is well known that finite state techniques have proven invaluable in a variety of natural language processing applications. A tool useful in natural language processing is the weighted finite state automata and weighted finite state transducer. Such a transducer is described in U.S. Pat. No. 6,032,111 to Mehryar Mohri, assigned to AT&T Corp., and which contents are incorporated herein by reference. Further background may be gained from “The Design Principles of a Weighted Finite-State Transducer Library” by Mehryar Mohri, Fernando Pereira and Michael Riley, available on the Internet at: http://citeseer.nj.nec.com/mohri00design.html; and “Weighted Automata in Text and Speech Processing”, by Mehryar Mohri, Fernando Pereira, and Michael Riley, found on the Internet at: http://citeseer.nj.nec.com/mohri96weighted.html. The contents of these two publications are incorporated herein by reference for background information.

FIG. 1 illustrates a weighted automaton 10 where each circle 12 is a “state” and the arrows between the states 14, 16 represent events causing the change of state. The weights given to the state transitions are positive real numbers representing negative logarithms of probabilities. Weights along the paths are added and when several paths correspond to the same string, the weight of the string is the minimum of the weights of those paths. Transitions 16 represent the

-weighted transitions discussed herein. The

-weighted transitions are “empty” strings with no value.

Weighted automata are efficient and convenient devices used in many applications such as text, speech and image processing. The automata obtained in such applications are often the result of various complex operations, some of them introducing the empty string “

”. For the most efficient use of an automaton, it is preferable to remove the

's of automata since in general they introduce delay when used. An algorithm that constructs an automaton B with no

's equivalent to an input automaton A with

's is called an “

-removal” algorithm.

The relevant art does not present

-removal of unweighted automata as an independent algorithm deserving a specific study. Instead, the

-removal process is often mixed with other optimization algorithms such as determinization. This usually makes the presentation of determinization more complex and the underlying ε-removal process obscure. Since

-removal is not presented as an independent algorithm, it is usually not analyzed and its running time complexity not clearly determined.

The present disclosure will provide discussion and explanation of a finite-state library algorithm for removal of an

-weight on automata and transducers. The concepts of weights to automata, automatons, and transducers, as well as known algorithms for

-removal are discussed. One of ordinary skill in the art will be familiar with the terms waited acceptor, weighted transducer, automata, automaton, and semiring. Background and information on these terms may be found in the references cited above as well as other well-known documentation.

Weight in the automata is a generalization of the notion of automaton: each transition of a weighted automaton is assigned a weight in addition to the usual labels. More formally, a weighted acceptor over finite alphabets and a semiring K is a finite directed graph with nodes representing states and arcs representing transitions in which each transition t is labeled with an input i(t)∈Σ and a weight w(t)∈K.

Furthermore, each state t has an initial weight and a final weight. In a weighted transducer, each transition t has also an output label o(t)

Δ* where Δ is the transducer's output alphabet. A state q is initial if λ(q)≠Ō, and final if p(q)≠Ō. For more information on the mathematical operations of the equations disclosed herein, see Werner Kuich and Arto Salomaa, Semirings, Automata, Languages, number 5 in EATCS Monographs on Theoretical Computer Science, published by Springer-Verlag, Berlin, Germany, 1986. A person of ordinary skill in the art will understand the algebraic operation and symbols used in the formulas disclosed herein. Therefore, an explanation of each algebraic operator and of the various terms used in the formulas is not provided.

In the design of a weighted finite state transducer library, most algorithms operate on general weighted automata and transducers. The general framework for solving all pairs shortest-paths problems—closed semirings—is compatible with the abstract notion of weights commonly used, thus it is preferable to include an efficient version of the generic algorithm of the Floyd-Warshall algorithm in some finite-state machine libraries. The Floyd-Warshall algorithm addresses the desire in finite-state machine libraries to determine the shortest distance between all nodes and all other nodes in the finite state machine. Determining these shortest distance values for each node to each other node relates to the problem of “All-Pairs-Shortest-Path” which is solved by the Floyd-Warshall algorithm. Using the Floyd-Warshall algorithm code can provide the all pairs shortest distances when the weights between the nodes are real numbers representing, for example, probabilities but also when they are strings or regular expressions. This case is useful to generate efficiently a regular expression equivalent to a given automaton. The Floyd-Warshall algorithm is also useful in the general

-removal algorithm discussed next.

Composition is the key operation on weighted transducers. The composition algorithm in the weighted case is related to the standard unweighted transducer composition and acceptor intersection algorithms, but in general weighted

-transitions complicate matters. The input or output label of a transducer transition may be the symbol

representing a null label. A null input label indicates that no symbol needs to be consumed when traversing the transition, and a null output label indicates that no symbol is output when traversing the transition. Null labels are needed because input and output strings do not always have the same length. For example, a word sequence is much shorter than the corresponding phonetic transcription. Null labels are a convenient way of delaying inputs or outputs, which may have important computation effects. In the weighted finite-state transducers used for example in speech recognition, transitions with null labels may also have a weight.

The presence of null labels makes the composition operation for weighted transducers more delicate than that for unweighted transducers. The problem is illustrated with the composition of the two transducers A and B shown in FIGS. 2( a) and 2(b). Transducer A has output null transitions, while transducer B has input null transitions. To help understand how these null transitions interact, refer to derived transducers A′ and B′ in FIGS. 2( c) and 2(d). In transducer A′, the output null transitions are labeled

₂, and the corresponding null moves in B′ are explicitly marked as self-transitions with input label

₂. Likewise, the input null transitions of B are labeled with

₁ in B′, and the corresponding self-transitions in A′ have output label

₁. Any transition in the composition of A and B has corresponding transition in the composition of A′ and B′, but whereas an output null label in A or an input null label in B corresponds to staying in the same state on the other transducer, in the composition of A′ and B′, the corresponding transition is made from a pair of transitions with matching A-output and B-input labels

_(i).

FIG. 3 illustrates the pseudocode of a generic epsilon removal algorithm for weighted automata. This

-removal algorithm is explained further in the article: “The Design Principles of a Weighted Finite-State Transducer Library” incorporated above. Given a weighted automaton M_(i), the algorithm returns an equivalents weighted automaton M_(o) without

-transitions. TransM[s] denotes to set of transitions leaving state s in an automaton M, Next(t) denotes the destination state of transition t, i(t) denotes its input label, and w(t) its weight. Lines 1 and 2 extract from M_(i) the subautomaton M_(e) containing all the non-

transitions. Line 3 applies the general all-pairs shortest distance algorithm CLOSURE to M

to derive the

-closure G

. The nested loops starting in lines 4, 5 and 6 iterate over all pair of an

-closure transition e and a non-

transition t such that the destination of e is the source of t. Line 7 looks in M_(o) for a transition t′ with label I(t) from e's source from t's destination if it exists, or creates a new one with eight O if it does not. This transition is the result of extending t “backwords” with the M_(i)

-path represented by

-closure transition e. Its weight, updated in line 8, is the semiring sum of such extended transitions with a given source destination and label.

In most speech processing applications, the appropriate weight algebra is the tropical semiring. Weights are positive real numbers representing negative logarithms of probabilities. Weights along the path are added; when several paths correspond the same string in the weight of the string is the minimum of the weights of those paths.

As noted before, the computation of the key closure requires the computation of the all pairs shortest distances in M_(e). In the case of idempotent semirings such as the tropical semiring, the most efficient algorithm available is Johnson's algorithm, which is based on the algorithms of Dykstra and Bellman-Ford. Details regarding Johnson's algorithm are found in T. Cormen, C. Leiserson and R. Rivest, Introduction to Algorithms, published by the MIT Press, Cambridge, Mass., 1992.

For running time, complexity of Johnson's algorithm is O(|Q|2 log|Q|+|Q||E|) when using Fibonacci heaps, but often the more general but less efficient Floyd-Warshall algorithm is used instead because it supports non-idempotent closed semirings. Further details regarding Fibonacci heaps are found in Introduction to Algorithms referenced above. When M

is acyclic, the linear time topological sort algorithm is used which also works with non-idempotent semirings.

FIG. 4 illustrates the result of an application of

-removal to a weighted automata of the tropical semiring of FIG. 1. The example shows that the

-removal algorithm generalizes the classical unweighted algorithm by ensuring that the weight of any string accepted by the automaton is preserved in the

-free result 20. In FIG. 4, the states 22 and transitions 24 of the

-free automaton 20 preserve the weight of any string accepted by the original automaton 10 shown in FIG. 1.

There are inefficiencies within the related use of

-removal algorithms. For example, the

-removal process is often presented in a mixture of other optimization algorithms such as determinations. See, e.g., A. V. Aho, R. Sethi, and J. D. Ullman, Compilers, Principles Techniques and Tools, published by Addison Wesley, Reading, Mass., 1986. A generalization of the Floyd-Warshall algorithm is typically used in connection with

-removal and introduces inefficiencies. First, in the

-removal algorithm explained above, M

was decomposed into strongly connected components, and then the Floyd-Warshall algorithm was applied to each component, and then the acyclic algorithm was applied to the component graph of M

to compute the final results. These computational inefficiencies experienced by using the Floyd-Warshall algorithm were usually accepted given that each strongly connected component of M

is small relative to M

's overall size.

Another disadvantage of obscuring the

-removal process via its use with other algorithms is the difficulty in an independent analysis of the running-time complexity and efficiency of

-removal. Therefore, accurate assessment of the efficiencies of such

-removal processes becomes very difficult.

SUMMARY OF THE INVENTION

What is needed in the art is an independent s-removal method for weighted automata and transducers defined over a semiring. The algorithm disclosed herein improves the efficiency of weighted automata used in applications such as speech recognition systems, speech synthesis systems and text processing systems. The

-removal method is preferably used in the case of unweighted automata and transducers and weighted automata and transducers defined over the tropical semiring based on the general shortest distance algorithm described herein.

An improved

-removal method is disclosed that computes for any input weighted automaton A with

-transitions an equivalent weighted automaton B with no

-transitions. The method comprises two main steps. The first step consists of computing for each state “p” of the input automaton A its

-closure denoted by C[p]: C[p]={(q,w):q∈

[p], d[p,q]=w∈K−{Ō}}

Where

[p] represents a set of states reachable from “p” via a path labeled with

. The second step consists of modifying the outgoing transitions of each state “p” by removing those labels with

and by adding to be non-

-transitions leading each state q with their weights pre-

-multiplied by d[p, q].

The second step in the method comprises modifying the outgoing transitions of each state “p” by removing those labeled with

. The method adds to the set of transitions leaving the state “p” non-

-transitions leaving each state “q” in the set of states reachable from “p” via a path labeled with

with their weights pre-

-multiplied by the

-distance from state “p” to state “q” in the automaton A. State “p” is a final state if some state “q” within the set of states reachable from “p” via a path labeled with

is final and the final weight ρ[p] is

${\rho\;\lbrack p\rbrack} = {\underset{{q\;\varepsilon\;{e{\lbrack p\rbrack}}} \Cap F}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack}{\rho\lbrack q\rbrack}} \right).}}$

The resulting automaton B is the equivalent of automaton A without the

-transitions. Furthermore, the method disclosed herein has been implemented and is up to 600 times faster than previously known methods based on generalizations of algorithms such as the Floyd-Warshall algorithm.

The epsilon removal algorithm according to an aspect of the present invention of weighted automatic and transducers is a general optimization algorithm useful in all applications where weighted automata and transducers are used: speech recognition, speech synthesis, text processing, genome processing, information extraction, etc. Thus the present invention provides a dramatic improvement in the removal of epsilons from word lattices, which are compact representations of a large number of recognition hypotheses with the associated weights, produced by a recognizer. The invention is preferably applied before the application of other optimizations such as weighted determinization and minimization.

BRIEF DESCRIPTION OF THE DRAWINGS

The foregoing advantages of the present invention will be apparent from the following detailed description of several embodiments of the invention with reference to the corresponding accompanying drawings, in which:

FIG. 1 illustrates a weighted automaton;

FIGS. 2( a)–2(b) illustrate the problem of the present of no labels that makes the composition operation for weighted transducers more difficult;

FIGS. 2( c)–2(d) illustrate how null transitions interact with relation to two derived transducers A′ and B′;

FIG. 3 illustrates a pseudocode of the related art general

-removal algorithm;

FIG. 4 illustrates a weighted automaton after an

-removal process;

FIG. 5 (a) illustrates a tropical semiring for a weighted automaton A with

transitions;

FIG. 5( b) illustrates a weighted automaton B equivalent to A result of the

-removal algorithm according to the first embodiment of the present invention;

FIG. 5( c) illustrates a weighted automaton C equivalent to A obtained by application of

-removal to the reverse of A;

FIG. 6( a) illustrates

-removal in the real semiring (R, +, *, 0, 1) for a weighted automaton A, where A

is k-closed for (R, +, *, 0, 1);

FIG. 6( b) illustrates a weighted automaton B equivalent to A output of the

-removal algorithm;

FIG. 7 illustrates a generic single source shortest distance algorithm used in connection with the first step in the first embodiment of present invention;

FIGS. 8( a) and 8(b) illustrate another aspect of the first embodiment of the invention regarding an input

-normalization method for weighted transducers; and

FIGS. 9( a) and 9(b) illustrate another aspect of the first embodiment of the invention regarding an input

-normalization method for weighted transducers.

DETAILED DESCRIPTION OF THE INVENTION

Presented and disclosed herein is a novel generic

-removal system and method for weighted automata and transducers defined over a semiring. The system or method can be used with any large class of semirings (framework) that covers the practical case of the semirings currently used for speech processing but that also includes other semirings that can be useful in speech and other domains. The system and method of the present invention also works with any queue discipline adopted, e.g., first-in-first-out (FIFO), shortest-first, etc. The present invention works with any k-closed semiring.

The present invention is particularly useful for unweighted automata and transducers and weighted automata and transducers defined over the tropical semiring. The invention is based on a general shortest-distance algorithm that is described briefly herein.

The method of the present invention is the first embodiment and will be described using example pseudocode and its running time complexity. The present disclosure further discusses the more efficient case of acyclic automata, an on-the-fly implementation of the method and an approximation method in the case of the semirings not covered by a specific framework.

First Embodiment

The first embodiment is illustrated with several semirings. Also described is an input

-normalization method for weighted transducers, which is based on the general shortest-distance algorithm. The

-normalization method, which works with all semirings covered by a specific framework, admits an on-the-fly implementation. An on-the-fly implementation allows one to use the algorithm with a lazy evaluation. In other words, instead of removing all the epsilons of the input machine all at once, one can remove only the epsilons that belong to the paths of the input that one might be interested in. So, when some part of the input machine A is read, the output B (w/o epsilons) is constructed just for that part of A.

As discussed above, weighted automata are automata in which the transitions are labeled with weights in addition to the usual alphabet symbols. For various operations to be well defined, the weight set needs to have the algebraic structure of a semiring. What follows includes some preliminary definitions and explanations of some terms necessary for understanding the present invention. A system K⊕

0 1 is a right semiring if:

-   -   1. (K⊕ 0) is a commutative monoid with 0 as the identity element         for ⊕,     -   2. (K         1) is a monoid with 1 as the identity element for         ,     -   3.         right distributes over ⊕: ∀a,b,c∈K, (a ⊕b)         c=(a         c)⊕(b         c),     -   4. 0 is an annihilator for         : ∀a∈K, a         0= 0         a= 0.

Left semirings are defined in a similar way by replacing right distributivity with left distributivity. (K, ⊕

, 0, 1) is a semiring if both left and right distributivity hold. Thus, more informally, a semiring is a ring that may lack negation. As an example, (N, +, ·, 0, 1) is a semiring defined on the set of nonnegative integers N.

A semiring (K, ⊕,

, 0, 1) is said to be idempotent if for any a∈K, a⊕a=a. The Boolean semiring β=({0, 1}, V, Λ, 0, 1) and the tropical semiring T=(RU{∞}, min, +, ∞, 0) are idempotent, but (N, +, ·, 0, 1) is not.

As a second definition, a weighted automaton A=(Σ, Q, I, F, λ, ρ) over the semiring K is a '7-tuple where Σ is the finite alphabet of the automaton, Q is a finite set of states, I

Q the set of initial states, F

Q the set of final states, E

Q×Σ×K×Q a finite set of transitions, λ:I→K is the initial weight function mapping I to K, and ρ:F→K is the final weight function mapping F to K.

Given a transition

∈E, according to the present disclosure, i[e] is denoted as its input label, w[e] its weight, p[e] its origin or previous state and n[e] its destination state or next state. Given a state q∈Q, E[q] is the set of transitions leaving q, and by E^(R)[q] the set of transitions entering q.

A path π=e₁ . . . e_(k) in A is an element of E* with consecutive transitions: n[e_(i−1)]=p[e_(i)], i=2, . . . , k. The variables n and p are extended to paths by setting: n[π]=n[e_(k)] and p[π]=p[e₁]. The notation P(q,q′) represents the set of paths from q to q′. P can be extended to subsets R

Q R′

Q, by:

${P\left( {R,R^{\prime}} \right)} = {\bigcup\limits_{{q \in R},{q^{\prime} \in R^{\prime}}}{P\left( {q,q^{\prime}} \right)}}$ The labeling function i and the weight function w can also be extended to paths by defining the label of a path as the concatenation of the labels of its constituent transitions, and the weight of a path as the

-product of the weights of its constituent transitions: i[π]=i[e₁] . . . i[e_(k)] w[π]=w[e₁]

. . .

w[e_(k)]

Given a string χ∈Σ*, P(χ) represents the set of paths from I to F labeled with P(χ)={π∈P ₍ I, F):i[π]=χ}

The output weight associated by A to an input string χ∈Σ* is:

${\lbrack A\rbrack(\chi)} = {\underset{\pi \in {P{(x)}}}{\oplus}{{\lambda\left( {p\lbrack\pi\rbrack} \right)} \otimes {w\lbrack\pi\rbrack} \otimes {p\left( {n\lbrack\pi\rbrack} \right)}}}$

If P(x)= 0, [A] (χ) is defined to be 0. Note that weighted automata over the Boolean semiring are equivalent to the classical unweighted finite automata.

These definitions can be easily generalized to cover the case of any weighted automata with

-transitions. An

-removal algorithm computes for any input weighted automaton A with

-transitions an equivalent weighted automaton B with no

-transition, that is such that: ∀χ∈Σ*, [A](χ)=[B](χ) Weighted finite-state transducers are defined in a similar way.

As a further definition, a weighted transducer T=(Σ, Ω, Q, I, F. E, λ, p) over the semiring K is an 8-tuple where Σ is the finite input alphabet of the transducer, Ω is the finite output alphabet of T, Q is a finite set of states, I

Q the set of initial states, F

Q the set of final states, E

Q×ΣU {oo}×Ω, U {oo}×K×Q a finite set of transitions, λ:I→K the initial weight function mapping I to K, and ρ:F→K the final weight function mapping F to K.

The output weight associated by T to an input string χ∈Σ and output string γ∈Ω is:

${\lbrack T\rbrack\left( {\chi,\gamma} \right)} = {\underset{\pi\;\varepsilon\;{P{({x,y})}}}{\oplus}{{\lambda\left( {p\lbrack\pi\rbrack} \right)}{w\lbrack\pi\rbrack}{p\left( {n\lbrack\pi\rbrack} \right)}}}$ where P(x, y) is the set of paths with input label x and output label y.

The following definitions will help to define the framework for the generic ε-removal algorithm of an embodiment of the present invention. Let k≧0 be an integer. A commutative semiring (K⊕

0 1) is k-closed if:

${\forall{{\alpha\varepsilon}\; K}},{{\underset{n = 0}{\overset{k + 1}{\oplus}}a^{n}} = {\underset{n = 0}{\overset{k}{\oplus}}a^{n}}}$

When k=0, the previous expression can be rewritten as: ∀α∈K, 1⊕α= 1 and K is then said to be bounded. Semirings such as the Boolean semiring β=({0, 1}, V, Λ, 0, 1) and the tropical semiring T=(R₊∪{∞}, min, +∞, 0) are bounded.

As yet another definition, let k≧0 be an integer, let (K⊕

0 1) be a commutative semiring, and let A be a weighted automaton over K. (K⊕

0 1) is right k-closed for A if for any cycle π of A:

${\underset{n = 0}{\overset{k + 1}{\oplus}}{\omega\lbrack\pi\rbrack}^{n}} = {\underset{n = 0}{\overset{k}{\oplus}}{\omega\lbrack\pi\rbrack}^{n}}$ By definition, if K is k-closed, then it is k-closed for any automaton over K.

Given the above definitions and preliminary information, the first aspect of the first embodiment of the present invention is described next. This embodiment generally discloses a method of

-removal for automatons. A second aspect of the first embodiment of the invention, discussed below, relates to an input

-normalization method for transducers. Further embodiments disclosed below relate to an apparatus or system for

-removal.

According to the first embodiment of the invention, let A=(Σ, Q, I, F, E, λ, ρ) be a weighted automaton over the semiring K with

-transitions. We denote by A

the automaton obtained from A by removing all transitions not labeled with

. We present a general

-removal algorithm for weighted automata based on a generic shortest-distance algorithm that works for any semiring K k-closed for A

. It is assumed that K has this property. This class of semirings includes in particular the Boolean semiring ({0, 1}, V, Λ, 0, 1), the tropical semiring (R₊∪{∞}, min, +∞, 0) and other semirings not necessarily idempotent.

The method of the first embodiment of the invention is presented by way of example for the case of weighted automata. The case of weighted transducers can be straightforwardly derived from the automata case by viewing a transducer as an automaton over the alphabet ΣU{

}×ΣU {

}. An

-transition of a transducer is then a transition labeled with (

,

).

For p, q in Q, the

-distance from p to q in the automaton A is denoted by d[p, q] and defined as:

${d\left\lbrack {p,q} \right\rbrack} = {\underset{{\pi\;\varepsilon\;{P{({p,q})}}},{{i{\lbrack\pi\rbrack}} = ɛ}}{\oplus}{\omega\lbrack\pi\rbrack}}$

This distance is well-defined for any pair of states (p,q) of A when K is a semiring k-closed for A

. By definition, for any p∈Q, d[p,p]= 1. The value d[p,q] is the distance from p to q in A

The class of semirings with which the generic shortest-distance algorithm works can in fact be extended to that of right semirings right k-closed for A

. Related disclosure is found in U.S. patent application Ser. No. 09/495,174, filed Feb. 1, 2001, by Mehryar Mohri, the contents of which application are incorporated herein.

The first embodiment of the invention comprises two main steps. The first step comprises computing for each state p of the input automaton A its

-closure denoted by C[p]: C[p]={(q,w):q∈ε[p], d[p,q]=w∈K−{Ō}} where ε[p] represents the set of states reachable from p via a path labeled with ε. This step is described in more detail later with a discussion of

-closures. The epsilon-closure step determines for each state p the set of states q that can be reached from p by paths labeled with epsilon. It also gives the total weight corresponding to all the on-paths from p to q. The states q and their weights are used in the second step to remove all the epsilon-paths from p to q, to create new transitions from p to q with their weights adjusted with the weights of the states q.

The second step comprises modifying the outgoing transitions of each state p by removing those labeled with ε and by adding to E[p] non-ε-transitions leaving each state q∈ε[p] with their weights pre-

-multiplied by d[p, q]. The following is example

-removal(A) pseudocode related to the second step of this embodiment of invention.

1 for each p ∈ Q 2 do E[p] ← {e ∈ E [p] : i[e] ≠ ε} 3 for each (q,w) ∈ C[p] 4 do E[p] ← E[p] ∪ {(p,a,w

w′,r) : (q, a, w′, r) ∈ E[q],a ≠ ε} 5 if q ∈ F 6 then if p ∉ F 7 then F ← F ∪ {p} 8 ρ[p] ← p[p] ⊕ (ω ⊕ ρ[q])

State p is a final state if some state q∈ε[p] is final. If so, then the final weight ρ[p] is then:

${\rho\;\lbrack p\rbrack} = {\underset{{q\;\varepsilon\;{e{\lbrack p\rbrack}}} \Cap F}{\oplus}\left( {{d\left\lbrack {p,q} \right\rbrack}{\rho\lbrack q\rbrack}} \right)}$

Note the difference in the equations between the Greek letter “ρ”and the English letter “p”. After removing

's at each state p, some states may become inaccessible if they could only be reached by

-transitions originally. Those states can be removed from the result in time linear in the size of the resulting machine using, for example, a depth-first search of the automaton. A depth-first search of the automaton may be accomplished, for example, by a classic algorithm disclosed in Introduction to Algorithm, by T. Cormen, C. Leiserson and R. Rivest, published by the MIT Press, Cambridge, Mass., 1992.

FIGS. 5( a)–(c) illustrate the use of the algorithm in the specific case of the tropical semiring. A tropical semiring A 30 is shown in FIG. 5( a). The states 32 are connected with some non-

-transitions 34 and some

-transitions 36. The

-transitions 36 can be removed in at least two ways: in the way described above, or the reverse.

FIG. 5( b) represents an automaton B produced by the

-removal method of the first embodiment of the invention. Each state 42 is connected by non-

-transitions 44 (only one transition is labeled but they are all non-

-transitions). FIG. 5( c) represents an automaton C produced by applying

-removal to the reverse of the automaton and re-reversing the result. As illustrated by FIGS. 5( b) and 5(c), different results can be obtained when applying the

-removal method to an automaton or the reverse of an automaton. The different result is due to two factors that are independent of the semiring.

First, the number of states in the original automaton A whose incoming transitions (or outgoing transitions in the reverse case) are all labeled with the empty string. As mentioned before, those states can be removed from the result. For example, state 3 of the automaton of FIG. 5( a) can only be reached by

-transitions and admits only outgoing transitions labeled with

. Thus, that state does not appear in the result in both methods (FIGS. 5( b)–(c)). The incoming transitions of state 2 are all labeled with

and thus it does not appear in the result of the

-removal with the first method, but it does in the reverse method because the outgoing transitions of state 2 are not all labeled with

.

The second factor is that the total number of non

-transitions of the states that can be reached from each state q in A

(the reverse of A

, in the reverse case). This corresponds to the number of outgoing transitions of q in the result of

-removal.

In practice, heuristics may reduce the number of states and transitions of the resulting machine although this will not affect the worst-case complexity of the method disclosed herein. One can for instance remove some

-transitions in the reverse way when that creates less transitions and others in the way corresponding to the first method when that helps reducing the resulting size.

FIGS. 6( a)–(b) illustrate the application of the

-removal algorithm of the first embodiment of the invention in the case of another semiring, the semiring of real numbers, or automaton A 60. As shown in FIG. 6( a), the states 62 are connected via non-

-transitions 64 and

-transitions 66. The automaton A

is k-closed for (R, +, *, 0, 1). FIG. 6( b) shows the weighted automaton B 70 with states 72 and all non-ε-transitions 74 (only one transition is labeled) that is equivalent to automaton A 60. The general algorithm applies in this case since A

is acyclic.

As mentioned above with respect to the first step of the method according to the first embodiment of the invention, the computation of

-closures is equivalent to that of all-pairs shortest-distances over the semiring K in A

There exists a generalization of the algorithm of Floyd-Warshall for computing the all-pairs shortest-distances over a semiring K under some general conditions. However, the running time complexity of that algorithm is cubic: O(|Q|³(T_(⊕)+T

+T_(*))) where T_(⊕), T

, and T_(*) denote the cost of ⊕,

, and closure operations in the semiring considered. The algorithm can be improved by first decomposing A

into its strongly connected components, and then computing all-pairs shortest distances in each components visited in reverse topological order. However, it is still impractical for large automata when A

, has large cycles of several thousand states. The quadratic space complexity O(|Q|²) of the algorithm also makes it prohibitive for such large automata. Another problem with this generalization of the algorithm of Floyd-Warshall is that it does not exploit the sparseness of the input automaton.

There exists a generic single-source shortest-distance algorithm that works with any semiring covered by the framework. The algorithm is a generalization of the classical shortest-paths algorithms to the case of the semirings of this framework.

This generalization is not trivial and does not require the semiring to be idempotent. In particular, a straightforward extension of the classical algorithms based on a relaxation technique would not produce the correct result in general. The algorithm is also generic in the sense that it works with any queue discipline. FIG. 7 illustrates the pseudocode of the algorithm. The algorithm of FIG. 7 works in particular with the semiring (R, +, *, 0, 1) when the weight of each cycle of A

admits a well-defined closure.

Referring to FIG. 7, a queue S is used to maintain the set of states whose leaving transitions are to be relaxed. S is initialized to {s}. For each state q∈Q, two attributes are maintained: d[q]∈K an estimate of the shortest distance from s to q, and r[q]∈K the total weight added to d[q] since the last time q was extracted from S. Lines 1–3 initialize arrays d and r. After initialization, d[q]r[q]=Ō for q∈Q−{s}, and d[s]=r[s]= 1.

Given a state q∈Q and a transition e∈E[q], a relaxation step on e is performed by lines 11–13 of the pseudocode, where r is the value of r[q] just after the latest extraction of q from S if q has ever been extracted from S, its initialization value otherwise.

Each time through the while loop of lines 5–15, a state q is extracted from S (lines 6–7). The value of r[q] just after extraction of q is stored in r, and then r[q]is set to Ō (lines 8–9). Lines 11–13 relax each transition leaving q. If the tentative shortest distance d[n[e]] is updated during the relaxation and if n[e] is not already in S, the state n[e] is inserted in S so that its leaving transitions be later relaxed (lines 14–15). Whenever d[n[e]] is updated, r[n[e]] is updated as well. r[n[e]] stores the total weight ⊕ added to d[n[e]] since n[e] was last extracted from S or since the time after initialization if n[e] has never been extracted from S. Finally, 16 resets the value of d[s] to 1.

In the general case, the complexity of the algorithm depends on the semiring considered and the queue discipline chosen for S:

$O\left( {{Q} + {\left( {T_{\oplus} + T_{\otimes} + {C(A)}} \right){E}{\max\limits_{q\;\varepsilon\; Q}{N(q)}}} + {\left( {{C(I)} + {C(E)}} \right)\Sigma_{q\;\varepsilon\; Q}{N(q)}}} \right)$ where N(q) denotes the number of times state q is extracted from S, C(E) the worst cost of removing a state q from the queue S, C(I) that of inserting q in S, and C(A) the cost of an assignment. This includes the potential cost of reorganization of the queue to perform this assignment.

In the case of the tropical semiring (R₊U {oo}, mm, +, oo, 0), the method shown in FIG. 7 coincides with classical single-source shortest-paths algorithms. In particular, it coincides with Bellman-Ford's algorithm when a FIFO queue discipline is used and with Dijkstra's algorithm when a shortest-first queue discipline is used. Using Fibonacci heaps, the complexity of Dijkstra's algorithm in the tropical semiring is: O(|E|+|Q|log |Q|) The book Introduction to Algorithms by Cormen, Leiserson and Rivest, referenced above, provides further material for these algorithms. The complexity of the algorithm is linear in the case of an acyclic automaton with a topological order queue discipline: O(|Q|+(T_(⊕)+T

)|E|) Note that the topological order queue discipline can be generalized to the case of non-acyclic automata A

, by decomposing A

, into its strongly connected components. Any queue discipline can then be used to compute the all-pairs shortest distances within each strongly connected component.

The all-pairs shortest-distances of A

can be computed by running |Q| times the generic single-source shortest-distance algorithm. Thus, when A

is acyclic, that is, when A

admits no

-cycle, then the all-pairs shortest distances can be computed in quadratic time: O(|Q²|+(T_(⊕)+T

)|Q||E|) When A

is acyclic, the complexity of the computation of the all-pairs shortest distances can be substantially improved if the states of A

are visited in reverse topological order and if the shortest-distance algorithm is interleaved with the actual removal of

's. Indeed, one can proceed in the following way for each state p of A

visited in reverse topological order: (1) Run a single-source shortest-distance algorithm with source p to compute the distance from p to each state q reachable from p by

's; and (2) Remove the

-transitions leaving q as described in the previous section.

The reverse topological order guarantees that the

-paths leaving p are reduced to the

-transitions leaving p. Thus, the cost of the shortest-distance algorithm run from p only depends on the number of c-transitions leaving p and the total cost of the computation of the shortest-distances is linear: O(|Q|+(T_(⊕)+T

_(l )|E|)) In the case of the tropical semiring and using Fibonacci heaps, the complexity of the first stage of the algorithm is: O(|Q|·|E|+|Q|²log|Q|)

In the worst case, in the second stage of the algorithm each state q belongs to the

-closure of each state p, and the removal of

's can create in the order of |E| transitions at each state. Hence, the complexity of the second stage of the algorithm is: O(|Q|²+|Q|·|E|) Thus, the total complexity of the algorithm in the case of an acyclic automaton A

is: O(|Q|²+(T_(⊕)+T

|Q|·|E|) In the case of the tropical semiring and with a non acyclic automaton A

, the total complexity of the algorithm is: O(|Q|·|E|+|Q|²log |Q|)

For some automata of about a thousand states with large

-cycles, the inventor of the present invention has implemented the automata with an improvement of up to 600 times faster than the previous implementation based on a generalization of the Floyd-Warshall algorithm.

An important feature of the system and method of the present invention is that it admits a natural on-the-fly implementation. Indeed, the outgoing transitions of state q of the output automaton can be computed directly using the

-closure of q. However, with an on-the-fly implementation, a topological order cannot be used for the queue S even if A

is acyclic since this is not known ahead of time. Thus, both an off-line and an on-the-fly version of the system and method of the present invention may be implemented. An on-the-fly algorithm can save space by removing only those epsilons that are necessary for the particular use of the input machine. An off-line algorithm simply applies to the entire machine and constructs the output regardless of what portion was really needed. In some cases as discussed above, the complexity of the off-line version is better because it can take advantage of the specific property of the machine (the fact that it is acyclic for example). This is not possible in the on-the-fly case. To allow for both uses, the present disclosure covers both the on-the-fly implementation and the off-line context.

The shortest-distance algorithm presented herein admits an approximation version where the equality of line 11 in the pseudocode of FIG. 7 is replaced by an approximate equality modulo some predefined constant δ. This can be used to remove

-transitions of a weighted automaton A over a semiring K such as (R, +, *, 0, 1), even when K is not k-closed for A

. Although the transition weights are then only approximations of the correct results, this may be satisfactory for many practical purposes such as speech processing applications. Furthermore, one can arbitrarily improve the quality of the approximation by reducing δ. As mentioned before, one can also use a generalization of the Floyd-Warshall algorithm to compute the result in an exact way in the case of machines A

with relatively small strongly connected components and when the weight of each cycle of A

admits a well-defined closure.

In another aspect of the first embodiment of the invention, a similar removal method is applied to transducers rather than automatons. The method according to this aspect of the first embodiment of the invention is closely related to the

-removal method described above. As shown in FIGS. 8( a), let T₁ 80 be a weighted transducer over a k-closed semiring K. T₁ includes states 82 and transitions with input label

84. In some applications, one may wish to construct a new transducer T₂ equivalent to T₁ such that T₂ has no

-transition and such that along any successful path of T₂, no transition with input label different from c is preceded with a transition with input label

. An exemplary transducer T₂ 90 is shown in FIG. 8( b) with states 92 and transitions 94 having the appropriate

-transition removes as described above. FIG. 8( b) is the output of epsilon normalization. You don't remove all epsilon translation.

A transducer such as T₂ 90 is input-normalized and a method for constructing T₂ 90 from T₁ 80 is called an input

-normalization method. The advantage of using a T₂ 90 so constructed is similar to the benefits of the

-removal method of the first aspect of the first embodiment of the invention. Matching its input with algorithms such as composition does not require any unnecessary delay due to the presence of input

's. FIGS. 8( a) and 8(b) illustrate the application of the algorithm in the case of a weighted transducer over the tropical semiring.

Note that the system (Σ*, ∪, ∩, Ø, Σ*) defines an idempotent semiring K′ over the set of strings Σ*. A weighted transducer T₁ 80 over the semiring K can be viewed as a weighted automaton A over the cross-product semiring S=K′×K. An element of S is a pair (χ, w) where χ∈Σ* is a string and w

K₁ the original weight of the transducer.

The input

-normalization method applies only to weighted transducers T₁ 80 over an arbitrary semiring K that do not admit any cycle with input label

. Cycles with both input and output can be removed using for example the

-removal method described according to the first aspect of the first embodiment of the invention. Since T₁ 80 does not admit any cycle with input label c, A does not admit any

-cycle and the semiring S is k-closed for A

. Thus the shortest-distance algorithm presented above can be used with A

and, more generally, the

-removal algorithm presented in the previous section applies to A.

This input

-normalization system and method relates to the

-removal method in the specific case of semirings of the S type. The result of the

-removal method is an acceptor with no

but with weights in S. FIG. 9( a) shows the result of that algorithm when applied to the transducer T₁ of FIG. 8( a). The transducer 100 of FIG. 9( a) includes states 102 and transitions 104 (not all labeled) without any

-transitions. The representation of transducers does not allow output labels to be strings, but transitions can be replaced with output strings by a set of consecutive transitions with outputs in Σ∪{

} in a trivial fashion. The result of that transformation is of interest and is useful in many contexts. However, the resulting transducer does not have the normalization property described above. To ensure that input

's are not found on a path before an input non-

label, there is a need to normalize the result of

-removal in a different way. To each state p, a residual output string y is associated that needs to be output from that state.

States in the result of

-normalization correspond to pairs (p, y) where p is a state of the original machine and y a residual output string. The residual string associated to an initial state is just

. The outgoing transitions of a state (p, y₀) are determined as follows. For each transition from state p to q with input label χ, output string y₁ and weight w₁ in the result of the

-removal algorithm, a transition is created from state (p, y₀) to state (q, a⁻¹y₀y₁), with input χ, output a and weight w₁, where a is the first letter of y₀y₁, a=

if y₀y₁

. A state (p, y₀) is final if p is a final state of the original machine and if y₀=

. When p is final and y₀≠

, then a transition is created from (p, y₀) to (p, y₁) with input

and output a with y₀ay₁.

FIG. 9 (b) illustrates this construction for the particular case of the transducer of FIG. 8 (a). As in the case of

-removal, input c-normalization admits a natural on-the-fly implementation since the outgoing transitions of state (p, y₀) 112 of the output automaton can be computed directly using only y₀ and the input

-closure of q. The transducer 110 of FIG. 9( b) illustrates states 112 and transitions 114.

The method according to the first embodiment of the invention may be implemented in numerous ways. For example, high level programming languages such as Basic, C or other programming language may be used to implement the method. The best mode of implementation is a software implementation using a high-level programming language.

Second Embodiment Of The Invention

The second embodiment of the invention relates to a system or apparatus for

-removal in automata. The system may comprise a variety of different forms. For example, a preferable aspect of the second embodiment of the invention is to provide a hardware implementation using electronic circuitry such as an EPROM, a programmable logic device (PLD) or a large group of logic gates. Some design tools such as SPLat (Simple Programmed Logic automation tool) boards have specifically been designed for implementation and programming of FSMs. Thus, circuit boards may be designed and created to carry out the functionality of the methods disclosed as part of the first embodiment of the invention. According to this embodiment of the invention, a hardware implementation such as a computer circuit, EPROM, or logic board is programmed to perform the steps set forth in the first embodiment of the invention. In this regard, the hardware, in whatever form, will receive an input weighted automaton A with

-transitions. Upon the operation of the hardware component to the automaton A with

-transitions, an equivalent weighted automaton B with no

-transitions is created.

The process performed by the hardware comprises two main steps. The first step consists of computing for each state “p” of the input automaton A its

-closure denoted by C[p]: C[p]={(q,w):q∈ε[p], d[p,q]=w

K−{Ō}}

Where

[p] represents a set of states reachable from “p” via a path labeled with

. The second step consists of modifying the outgoing transitions of each state “p” by removing those labels with

and by adding to be non-

-transitions leading each state q with their weights pre-

-multiplied by d[p,q].

The second step in the method comprises modifying the outgoing transitions of each state “p” by removing those labeled with

. The method adds to the set of transitions leaving the state “p” non-

-transitions leaving each state “q” in the set of states reachable from “p” via a path labeled with

with their weights pre-

-multiplied by the

-distance from state “p” to state “q” in the automaton A. State “p” is a final state if some state “q” within the set of states reachable from “p” via a path labeled with

is final and the final weight

${{\rho\;\lbrack p\rbrack}\mspace{14mu}{is}\mspace{14mu}{\rho\;\lbrack p\rbrack}} = {\underset{{q\;\varepsilon\;{e{\lbrack p\rbrack}}} \Cap F}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack}{\rho\lbrack q\rbrack}} \right).}}$

One aspect of the second embodiment of the invention relates to a computer readable medium such as a data disc or other medium having a program stored thereon that is operable to perform the method or process described with respect to the first embodiment of the invention. In this regard, executable code or source code may be stored on the computer readable medium. Those of ordinary skill in the art will understand and recognize how to create such a computer readable medium according to this embodiment of the invention given the understanding of the method according to the first embodiment of the invention. The computer readable medium may be, for example, a computer disk, hard disk, read-only-memory, or random access memory.

Third Embodiment of the Invention

The third embodiment of the invention relates to product produced by the process described above with respect to the method explained above. Specifically, the equivalent weighted automaton B with no

-transitions is a product that is created by the process set forth and described above as the first embodiment of the invention. Therefore, the third embodiment of the invention relates to an automaton having no

-transitions, the automaton being created according to the

-removal algorithms described herein.

What follows is a series of equations related to process of Generic ε-Removal and Input ε-Normalization Algorithms for Weighted Transducers. We begin with a theorem and then the proof of the theorem. The following theorem and proof provide disclosure related to another aspect of the present invention.

-   Theorem 1 Let A=(Σ, Q, I, F, E, λ, ρ) be a weighted automaton over     the semiring K right k-closed for A. Then the weighted automaton B     result of the     -removal algorithm just described is equivalent to A. -   Proof. We show that the function defined by the weighted automaton A     is not modified by the application of one step of the loop of the     pseudocode above. Let A=(Σ, Q, I, F, E, λ, ρ) be the automaton just     before the removal of the ε-transitions leaving state p∈Q.

Let χ∈Σ*, and let Q(p) denote the set of successful paths labeled with χ passing through p and either ending at p or following an ε-transition of p. By commutativity of ⊕, we have:

${\lbrack A\rbrack(\chi)} = {\underset{\pi \in {{P{(x)}} - {Q{(p)}}}}{\oplus}{{{\lambda\left( {p\lbrack\pi\rbrack} \right)} \otimes {\omega\lbrack\pi\rbrack} \otimes {\rho\left( {n\lbrack\pi\rbrack} \right)}} \oplus {\underset{\pi \in {Q{(p)}}}{\oplus}{{\lambda\left( {\rho\lbrack\pi\rbrack} \right)} \otimes {\omega\lbrack\pi\rbrack} \otimes {\rho\left( {\eta\lbrack\pi\rbrack} \right)}}}}}$ Denoted by S₁ and S₂ are the first and second term of that sum. The

-removal at state p does not affect the paths not in Q(p), thus we can limit our attention to the second term S₂. A path in Q(p) can be factored in: π=π₁, π₂, π₃ where π_(ε), is a portion of the path from p to nπ_(ε)=q labeled with ε. The distributivity of

over ⊕ gives us:

$\left. {S_{2} = \left( {\underset{{n\lbrack{\pi\;}_{1}\rbrack} = \rho}{\oplus}{{\lambda\left( {p\left\lbrack \pi_{1} \right\rbrack} \right)} \otimes {\omega\left\lbrack \pi_{1} \right\rbrack}}} \right)} \right) \otimes S_{22}$ with:

$\begin{matrix} {S_{22} = {\left( {\underset{{{p{\lbrack\pi_{ɛ}\rbrack}} = p},{{n\;\lbrack\pi_{ɛ}\rbrack} = q}}{\oplus}{\omega\;\left\lbrack \pi_{e} \right\rbrack}} \right) \otimes {\underset{{\rho{\lbrack\pi_{2}\rbrack}} = q}{\oplus}{{\omega\left\lbrack \pi_{2} \right\rbrack} \otimes {\rho\left( {n\left\lbrack \pi_{2} \right\rbrack} \right)}}}}} \\ {= {{d\left\lbrack {p,q} \right\rbrack} \otimes {\underset{{p{\lbrack\pi_{2}\rbrack}} = q}{\oplus}{{\omega\left\lbrack \pi_{2} \right\rbrack} \otimes {\rho\left( {n\left\lbrack \pi_{2} \right\rbrack} \right)}}}}} \\ {= {\underset{{p{\lbrack\pi_{2}\rbrack}} = q}{\oplus}\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\omega\left\lbrack \pi_{2} \right\rbrack} \otimes {\rho\left( {n\left\lbrack \pi_{2} \right\rbrack} \right)}} \right.}} \end{matrix}$ For paths π such that π_(2=ε:)

$S_{22} = {\underset{{{p\lbrack\;\pi_{2}\rbrack} = q},{q\;\varepsilon\;{ɛ{\lbrack p\rbrack}}}}{\oplus}\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\rho(q)}} \right)}$ which is exactly the final weight associated to p by ε-removal at p. Otherwise, by definition of π_(ε), π₂ does not start with an ε-transition. The second term of the sum defining S₂₂ can thus be rewritten as:

$S_{22} = {\underset{{e\;\varepsilon\;{E{\lbrack q\rbrack}}},{{i{\lbrack e\rbrack}} \neq \varepsilon},{\pi_{2} = {e\;\pi_{2}^{\prime}}}}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\omega\lbrack e\rbrack}} \right) \otimes {\omega\left\lbrack \pi_{2}^{\prime} \right\rbrack} \otimes {\rho\left( {n\left\lbrack \pi_{2} \right\rbrack} \right)}}}$ The

-removal step at state p follows exactly that decomposition. It adds non

-transitions e leaving q with weights (d[p, q]

w[e]) to the transitions leaving p. This ends the proof of the theorem.

Although the above description may contain specific details, they should not be construed as limiting the claims in any way. Other configurations of the described embodiments of the invention are part of the scope of this invention. For example, finite state machines may be used to design computer programs, logic circuits, or electronic control systems. The

-removal algorithm and other algorithms disclosed herein may clearly have application outside of speech processing. For example, the same algorithm (epsilon-removal) applies in contexts similar to speech such as text processing, information extraction, information retrieval, computational biology, etc. where weighted automata are used and where one wishes to make their use more efficient. Furthermore, the system and method disclosed here can be straightforwardly modified to remove transitions with a label a different from

. This can be done for example by replacing

by a new label and a by

, applying

-removal and then restoring original

's. Accordingly, the appended claims and their legal equivalents should only define the invention, rather than any specific examples given. 

1. A method of removing empty string terms from an automaton A having a plurality of states “p”, a plurality of states “q”, and a plurality of outgoing transitions from the plurality of states “p”, E[p], the method comprising: inputting a plurality of electrical signals representing the automaton A, the automaton A further representing a plurality of hypotheses with associated weights; computing an

-closure for each of the plurality of states “p” of the automaton A; producing a plurality of electrical signals representing an improved automaton A, the producing comprising modifying E[p] by: removing each of the plurality of transitions labeled with an empty string; and adding to the plurality of outgoing transitions, E[p], a non-empty-string transition, wherein each of the plurality of states “q” is left with its weights pre-multiplied by an

-distance from a corresponding one of the plurality of states “p” to a respective one of the plurality of states “q” in the automaton A.
 2. The method of claim 1, wherein the producing of the plurality of electrical signals representing the improved automaton A further comprises: removing inaccessible ones of the plurality of the states “p” and “q” using a depth-first search of the automaton A.
 3. The method of claim 1, wherein adding to the plurality of outgoing transitions, E[p], a non-empty-string transition further comprises leaving each of the plurality of states “q” with weights (d[p,q]

ρ[q]) to E[p].
 4. The method of claim 1, wherein the computing of the

-closure for each of the plurality of states “p” of the input automaton A further comprises: removing all transitions not labeled with an empty string from the automaton A to produce an automaton A

; decomposing the automaton A

into its strongly connected components; and computing all-pairs shortest distances in each of the strongly connected components visited in reverse topological order.
 5. The method of claim 1, wherein the computing of the

-closure for each of the plurality of states “p” of the input automaton A further comprises: removing all transitions not labeled with an empty string from the automaton A to produce an automaton A

; decomposing A

into its strongly connected components; performing a single-source shortest-distance algorithm according to the following pseudo code: for each p∈Q do d[p]←r[p]←Ō d[s]←r[s]← 1 S←{s} while S≠0 do q←head [S] DEQUEUE (S) r←r[q] r[q]←Ō for each e∈E[q] do if d[n[e]]≠d[n[e]]⊕(r

w[e]) then d[n[e]]←d[n[e]]⊕(r

w[e]) r[n[e]]←r[n[e]]⊕(r

w[e]) if n[e]∉S then ENQUEUE (S, n[e]) d[s]←
 1. 6. The method of claim 1, wherein the the computing of the

-closure for each of the plurality of states “p” further comprises computing each of the

-closures according to the following equation: C[p]={(q,w):q∈

[p], d[p,q]=WεK−{Ō}}.
 7. The method of claim 6, further comprises modifying the outgoing transitions of each of the plurality of states p according to the following procedure: for each p∈Q do E[p]←{e∈E [p]: i[e]≠ε} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′,r):(q, a, w′, r)

E[q],a ≠

} if q∈F  then if p∉F  then F←F∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]).
 8. The method of claim 7, wherein a state is a final state if at least one of the plurality of states “q” within a set of states reachable from one of the plurality of states “p” via a path labeled with an empty string is final and the final weight is then: ${\rho\lbrack p\rbrack} = {\underset{g \in \;{{ɛ{\lbrack p\rbrack}}\bigcap F}}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\rho\lbrack q\rbrack}} \right).}}$
 9. The method of claim 8, further comprising: performing a depth-first search of the automaton A after removing the empty strings.
 10. A method of producing an equivalent weighted automaton “B” with no

-transitions for any input weighted automaton “A” having at least one

-transition, the automaton “A” having a plurality of states “p”, and a plurality of states “q”, the method comprising: inputting a plurality of electrical signals representing the input weighted automaton A, the weighted automaton A further representing a plurality of hypotheses with associated weights; computing an

-closure for each of the plurality of states “p” of the input weighted automaton “A”; and producing a plurality of electrical signals representing the automaton “B” equivalent to automaton A without the

-transitions, the producing comprising: modifying outgoing transitions of each of the plurality of states “p” by: removing each transition labeled with an empty string; and adding to a plurality of outgoing transitions from the plurality of states “p” a non-empty-string transition, wherein each of the plurality of states “q” is left with its weights pre-multiplied by an

-distance from a corresponding one of the plurality of states “p” to a respective one of the plurality of states “q” in the automaton “A” to produce the automaton “B”, the automaton “B” representing an improved version of the plurality of hypotheses.
 11. The method of claim 10, further comprising: removing inaccessible states of the automaton “A” using a depth-first search of the automaton “A”.
 12. The method of claim 11, wherein adding to the plurality of outgoing transitions from the plurality of states “p” a non-empty-string transition further comprises leaving each of the plurality of states “q” with weights (d[p,q]

ρ[q]) to the transitions leaving corresponding ones of the plurality of states “p”.
 13. The method of claim 10, wherein the computing of the

-closure for each of the plurality of states “p” of the input automaton “A” further comprises: removing all non-

-transitions to produce an automaton A

; decomposing the automaton A

into its strongly connected components; and computing all-pairs shortest distances in each of the strongly connected components visited in reverse topological order.
 14. The method of claim 10, wherein the computing of the

-closure for each of the plurality of states “p” further comprises computing each of the

-closures according to the following equation: C[p]={(q,w):q∈

[p], d[p,q]=w∈K−{Ō}}.
 15. The method of claim 14, wherein the modifying the outgoing transitions of each of the plurality of states “p” further comprises modifying the outgoing transitions of each of the plurality of states p according to the following procedure: for each p∈Q do E[p]←{e∈E [p]: i[e]≠

} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′,r):(q, a, w′, r)∈E[q],a ≠

} if q

F  then if p∉F  then F←F∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]).
 16. The method of claim 10, further comprising modifying a plurality of outgoing transitions from the states “p”, E[p], according to the following procedure: for each p∈Q do E[p]←{e∈E [p]:i[e]≠

} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′, r):(q, a, w′, r)∈E[q], a≠

} if q∈F  then if p∉F  then F←F∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]).
 17. A method of producing an automaton B from an automaton A, the automaton B having no empty string transitions, the method comprising: inputting a plurality of electrical signals representing the automaton A, the automaton A further representing a plurality of hypotheses with associated weights; computing for each state p in the automaton A its

-closure C[p] according to the following: C[p]={(q,w):q∈

[p], d[p,q]=w∈K−{Ō}}, where

[p] represents states labeled with an empty string; removing each transition labeled with an empty string; and producing a plurality of electrical signals representing the automaton B, the automaton B being equivalent to the automaton A without

-transitions, the producing comprising: adding to each transition leaving the states “p” a non-empty-string transition, wherein each state “q” in the automaton A is left with its weights pre-multiplied by an

-distance from one of the states “p” to a respective one of the states “q” in the automaton “A” to produce the automaton “B”.
 18. The method of claim 17, wherein the adding the non-empty-string transition to each of the transitions leaving the states “p” is performed according to the following code: for each p∈Q do E[p]←{e∈E [p]:i[e]≠

} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′,r):(q, a, w′, r)∈E[q],a ≠

} if q∈F  then if p∉F then F←F ∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]), where E[p] is plurality of outgoing transitions from the states “p”.
 19. A method of producing an equivalent weighted automaton “B” with no

-transitions for any input weighted automaton “A” having a set of transitions E, wherein each transition “e” in the set of transitions has an input label i[e], at least one transition being an

-transition, a set of states P, each state in the set of states P is denoted as “p”, and a set of states Q, each state in the set of states Q denoted as “q”, a weight w[e] for each transition “e”, and E[p] the transitions leaving each state “p” and E[q] being the transitions leaving state “q”, an

-closure for a state being defined as C[p], and where

[p] represents a set of states reachable from state “p” via a path labeled with an

-transition, the method comprising: inputting a plurality of electrical signals representing the weighted automaton A, the weighted automaton A further representing a plurality of hypotheses with associated weights; computing an

-closure C[p] for each state “p” of the input weighted automaton “A”; removing each

-transition of the weighted automaton A to produce an automaton A

; and producing a plurality of electrical signals representing the automaton B, the automaton B being equivalent to the automaton A without

-transitions, the producing further comprising: adding to E[p] non-empty-string transitions leaving each state “q” from the set of states reachable from “p” via a path labeled with an

-transition, wherein each state “q” is left with its weights pre-multiplied by an

-distance from state “p” to “q” in the automaton “A” to produce the automaton “B”.
 20. A method of producing an equivalent weighted automaton “B” with no

-transitions for any input weighted automaton “A” having a set of transitions “e”, at least one of which is an

-transition, a set of states “p”, and a set of states “q”, the method comprising: inputting a plurality of electrical signals representing the weighted automaton A, the weighted automaton A further representing a plurality of hypotheses with associated weights; and producing a plurality of electrical signals representing the automaton B with no

-transitions, the producing comprising: computing an

-closure C[p] for each state “p” of the input weighted automaton “A”; for each of the states “p”, determining non-

-transitions from the states “p”; for each of the states “q” having a weight “w” within the computed

-closure C[p]: adding to outgoing transitions from the states “p”, E[p], the non-

-transitions leaving each of the states “q”; and if one of the states “q” is part of a set of final states F, and if a corresponding one of the states “p” is not part of the set of final states F: defining the corresponding one of the states “p” as included within the set of final states “F” and a final weight ρ[p] as pre-

multiplied by w, the

-distance from state “p” to state “q” in the automaton A to produce the automaton B.
 21. A method of removing string terms “a” from an automaton A having a set of states “p”, a set of states “q”, and a set of outgoing transitions from the set of states “p”, E[p], the method comprising: inputting a plurality of electrical signals representing the automaton A, the automaton A further representing a plurality of hypotheses with associated weights; producing a plurality of electrical signals representing an automaton B from the automaton A, the producing comprising; computing an a-closure for each state “p” of the automaton A; and modifying E[p] by: removing each transition labeled with a string term “a”; and adding to E[p] a non-“a”-string transition, wherein each state “q” is left with its weights pre-

-multiplied by an a-distance from state “p” to a state “q” in the automaton A to produce the automaton B.
 22. The method of claim 21, further comprising: removing inaccessible states using a depth-first search of the automaton A.
 23. The method of claim 21, wherein adding to E[p] a non-“a”-string transition further comprises leaving the state “q” with weights (d[p,q]

ρ[q]) to E[p].
 24. The method of claim 21, wherein the computing of an a-closure for each state “p” of an input automaton A further comprises: removing all transitions not labeled with a string “a” from automaton A to produce an automaton A_(a); decomposing A_(a) into its strongly connected components; and computing all-pairs shortest distances in each of the strongly connected components visited in reverse topological order.
 25. The method of claim 21, wherein the computing of an a-closure for each state “p” of an input automaton A further comprises: decomposing A_(a) into its strongly connected components; performing a single-source shortest-distance algorithm according to the following pseudo code: for each p∈Q do d[p]←r[p]←Ō d[s]←r[s]← 1 S←{s} while S≠0 do q←head [S] DEQUEUE (S) r←r[q] r[q]←Ō for each e∈E[q] do if d[n[e]]≠d[n[e]]⊕(r

w[e]) then d[n[e]]←d[n[e]]⊕(r

w[e]) r[n[e]]←r[n[e]]⊕(r

w[e]) if n[e]∉S then ENQUEUE (S, n[e]) d[s]←
 1. 26. The method of claim 21, wherein the computing of the a-closure for each state “p” further comprises computing each of the a-closures according to the following equation: C[p]={(q,w):q∈a[p], d[p,q]=w∈K−{Ō}}.
 27. The method of claim 26, wherein the modifying of E[p] further comprises modifying the outgoing transitions of each state “p” according to the following procedure: for each p∈Q do E[p]←{e∈E [p]:i[e]≠a} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′,r):(q, a, w′, r)∈E[q],a≠a} if q∈F  then if p∉F  then F←F∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]).
 28. The method of claim 27, wherein a state is a final state if some state “q” within a set of states reachable from “p” via a path labeled with an empty string is final and a final weight is then: ${\rho\lbrack p\rbrack} = {\underset{{q\;\varepsilon\;{e{\lbrack p\rbrack}}} \Cap F}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\rho\lbrack q\rbrack}} \right).}}$
 29. The method of claim 28, further comprising: performing a depth-first search of the automaton A after removing the “a” strings.
 30. A method of removing empty string terms from a transducer A having a set of states “p”, a set of states “q”, and a set of outgoing transitions from the set of states “p”, E[p], the method comprising: inputting a plurality of electrical signals representing the transducer A; and generating a plurality of electrical signals representing a modified transducer A by: computing an

-closure for each of the states “p” of the transducer A; modifying E[p] by: removing each transition labeled with an empty string; adding to the E[p] a non-empty-string transition, wherein each of the states “q” is left with its weights pre-multiplied by an

-distance from a corresponding one of the states “p” to a respective one of the states “q” in the transducer A to generate the modified transducer A.
 31. The method of claim 30, further comprising: removing inaccessible states using a depth-first search of the transducer A.
 32. The method of claim 30, wherein adding to E[p] non-empty-string transitions further comprises leaving the states q with weights (d[p,q]

ρ[q]) to E[p].
 33. The method of claim 30, wherein the computing of the

-closure for each of the states “p” of the transducer A further comprises: removing all transitions not labeled with an empty string from transducer A to produce a transducer A

; decomposing A

into its strongly connected components; and computing all-pairs shortest distances in each of the strongly connected components visited in reverse topological order.
 34. The method of claim 30, wherein the computing of the

-closure for each of the states “p” of the transducer A further comprises: decomposing A

into its strongly connected components; performing a single-source shortest-distance algorithm according to the following pseudo code: for each p∈Q do d[p]←r[p]←Ō d[s]←r[s]← 1 S←{s} while S≠0 do q←head [S] DEQUEUE (S) r←r[q] r[q]←Ō for each e∈E[q] do if d[n[e]]≠d[n[e]]⊕(r

w[e]) then d[n[e]]←d[n[e]]⊕(r

w[e]) r[n[e]]←r[n[e]]⊕(r

w[e]) if n[e]∉S then ENQUEUE (S, n[e]) d[s]←
 1. 35. The method of claim 30, wherein the computing of the

-closure for each state of the states “p” further comprises computing each the

-closure according to the following equation: C[p]={(q,w):q∈ε[p], d[p,q]=w

K−{Ō}}.
 36. The method of claim 35, wherein the modifying of the outgoing transitions of each of the states “p” further comprises modifying the outgoing transitions of each p of the states “p” according to the following procedure: for each p∈Q do E[p]←{e∈E [p]:i[e]≠

} for each (q,w)∈C[p] do E[p]←E[p]∪{(p,a,w

w′,r):(q, a, w′, r)∈E[q],a≠

} if q∈F  then if p∉F then F←F∪{p}  ρ[p]←p[p]⊕(ω⊕ρ[q]).
 37. The method of claim 36, wherein a state is a final state if some state “q” within a set of states reachable from a corresponding state “p” via a path labeled with an empty string is final and the final weight is then: ${\rho\lbrack p\rbrack} = {\underset{g \in \;{{ɛ{\lbrack p\rbrack}}\bigcap F}}{\oplus}{\left( {{d\left\lbrack {p,q} \right\rbrack} \otimes {\rho\lbrack q\rbrack}} \right).}}$
 38. The method of claim 37, further comprising: performing a depth-first search of the transducer A after removing the empty strings. 